package com.pai4j.aigc.controller;

import com.pai4j.aigc.context.ContextKit;
import com.pai4j.aigc.context.entity.ChatSessionEntity;
import com.pai4j.aigc.context.model.ChatMessageContext;
import com.pai4j.aigc.context.service.ChatContextService;
import com.pai4j.common.bean.PAIResponseBean;
import com.pai4j.common.bean.PAIResponseBeanUtil;
import jakarta.annotation.Resource;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/aigc-service/context")
public class ContextController {

    @Resource
    private ChatContextService chatContextService;
    /**
     * 创建一个新的会话或确保已有会话有效。
     *
     * @param userId   用户ID，标识当前操作的用户
     * @param botId    机器人ID，标识当前交互的机器人
     * @param sessionId 可选参数，指定已存在的会话ID；若未提供，则创建新会话
     * @return 返回包含会话ID的响应对象
     */
    @PostMapping("/session/create")
    public PAIResponseBean<String> createSession(@RequestParam String userId,
                                                 @RequestParam String botId,
                                                 @RequestParam(required = false) String sessionId,
                                                 @RequestParam(required = false, defaultValue = "false") Boolean newSession) {
        String sid;
        if (Boolean.TRUE.equals(newSession)) {
            sid = chatContextService.createNewSession(userId, botId);
        } else {
            sid = ContextKit.ensureSession(userId, botId, sessionId);
        }
        return PAIResponseBeanUtil.success(sid);
    }

    /**
     * 重命名指定会话的标题。
     *
     * @param sessionId 会话ID，标识需要重命名的会话
     * @param title     新的会话标题
     * @return 返回操作是否成功的响应对象
     */
    @PostMapping("/session/rename")
    public PAIResponseBean<Boolean> rename(@RequestParam String sessionId,
                                           @RequestParam String title) {
        chatContextService.renameSession(sessionId, title);
        return PAIResponseBeanUtil.success(true);
    }

    /**
     * 关闭指定的会话。
     *
     * @param sessionId 会话ID，标识需要关闭的会话
     * @return 返回操作是否成功的响应对象
     */
    @PostMapping("/session/close")
    public PAIResponseBean<Boolean> close(@RequestParam String sessionId) {
        chatContextService.closeSession(sessionId);
        return PAIResponseBeanUtil.success(true);
    }

    /**
     * 获取用户的会话列表，支持分页和排序。
     *
     * @param userId    用户ID，用于筛选该用户下的会话
     * @param botId     可选参数，用于筛选与特定机器人相关的会话
     * @param page      可选参数，分页页码（从0开始）
     * @param size      可选参数，每页数据条数
     * @param sortField 可选参数，排序字段，默认为"lastMessageAt"
     * @param order     可选参数，排序方式（asc/desc），默认为"desc"
     * @return 返回会话列表的响应对象
     */
    @GetMapping("/session/list")
    public PAIResponseBean<List<ChatSessionEntity>> list(@RequestParam String userId,
                                                         @RequestParam(required = false) String botId,
                                                         @RequestParam(required = false) Integer page,
                                                         @RequestParam(required = false) Integer size,
                                                         @RequestParam(required = false) String sortField,
                                                         @RequestParam(required = false) String order) {
        if (page == null || size == null) {
            // 若未提供分页信息，则返回全部会话列表
            return PAIResponseBeanUtil.success(chatContextService.listSessions(userId, botId));
        }
        String sf = (sortField == null || sortField.isEmpty()) ? "lastMessageAt" : sortField;
        String ord = (order == null || order.isEmpty()) ? "desc" : order;
        // 使用分页和排序参数获取会话列表
        return PAIResponseBeanUtil.success(chatContextService.listSessions(userId, botId, page, size, sf, ord));
    }

    /**
     * 获取指定会话中的最近消息列表。
     *
     * @param sessionId 会话ID，标识要查询的消息所属会话
     * @param limit     最大返回消息数量，默认为20条
     * @return 返回消息列表的响应对象
     */
    @GetMapping("/session/messages")
    public PAIResponseBean<List<ChatMessageContext>> messages(@RequestParam String sessionId,
                                                              @RequestParam(defaultValue = "20") Integer limit) {
        return PAIResponseBeanUtil.success(chatContextService.loadRecent(sessionId, limit));
    }

    /**
     * 获取指定会话中的最近消息列表（JSON数组字符串形式）。
     */
    @GetMapping("/session/messages-json")
    public PAIResponseBean<String> messagesJson(@RequestParam String sessionId,
                                                @RequestParam(defaultValue = "20") Integer limit) {
        return PAIResponseBeanUtil.success(chatContextService.loadRecentJson(sessionId, limit));
    }

    /**
     * 对指定会话进行摘要处理（如生成摘要内容）。
     *
     * @param sessionId 会话ID，标识需要处理的会话
     * @return 返回操作是否成功的响应对象
     */
    @PostMapping("/session/summarize")
    public PAIResponseBean<Boolean> summarize(@RequestParam String sessionId) {
        chatContextService.summarizeIfNeeded(sessionId);
        return PAIResponseBeanUtil.success(true);
    }

    /**
     * 导出指定会话的所有消息内容。
     *
     * @param sessionId 会话ID，标识需导出消息的会话
     * @return 返回完整消息列表的响应对象
     */
    @GetMapping("/session/export")
    public PAIResponseBean<List<ChatMessageContext>> export(@RequestParam String sessionId) {
        return PAIResponseBeanUtil.success(chatContextService.exportMessages(sessionId));
    }

    /**
     * 删除指定ID的消息记录。
     *
     * @param id 消息ID，标识需要删除的消息
     * @return 返回操作是否成功的响应对象
     */
    @PostMapping("/message/delete")
    public PAIResponseBean<Boolean> deleteMessage(@RequestParam Long id) {
        chatContextService.deleteMessage(id);
        return PAIResponseBeanUtil.success(true);
    }

    /**
     * 清空指定会话中的所有消息。
     *
     * @param sessionId 会话ID，标识需要清空消息的会话
     * @return 返回操作是否成功的响应对象
     */
    @PostMapping("/session/clear")
    public PAIResponseBean<Boolean> clearSession(@RequestParam String sessionId) {
        chatContextService.deleteAllMessages(sessionId);
        return PAIResponseBeanUtil.success(true);
    }

}
